home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 7 / FM Towns Free Software Collection 7.iso / t_os / bb / src / insub.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-30  |  15.1 KB  |  650 lines
  1. /*
  2.     input subroutine
  3.         key_in  :  key board input (encode mode)
  4.                     up, down, right, left key & ESC key
  5.         mouse_in:  mouse input
  6.                     left, right bottan
  7.         pad_in  :  pad input
  8.                     A, B trigger, up, down, right, left key & RUN, SEL trigger
  9.         menuread:  menu display and select
  10.                     panel display, panel read call
  11.  
  12.                       1993.6.27 v1.0
  13.                       copyright Y.Ouchi
  14.  
  15. */
  16.  
  17. #include    <string.h>
  18. #include    <register.h>
  19. #include    "mos.h"
  20. #include    "snd.h"
  21. #include    "egb.h"
  22. #include    "bb.h"
  23.  
  24. extern    char    moswork[];
  25. extern    char    egbwork[1536];
  26.  
  27.     /* 関数プロトタイプ宣言 */
  28. int        intreal(int, union REGS *, union REGS *, struct SREGS *);
  29.  
  30. extern    void    box(int, int, int, int, int, int);
  31. extern    void    linedsp(int, int, char *);
  32. extern    void    linedspv(int, int, char *, int, unsigned int, unsigned int);
  33.  
  34. static    char    *menutable[16]={"NEXT TITLE",
  35.                             "PREVIOUS TITLE",
  36.                             "TOP TEXT",
  37.                             "LAST TEXT",
  38.                             "LOG UPDATE & QUIT",
  39.                             "QUIT",
  40.                             "TITLE MODE",
  41.                             "NEW FILE",
  42.                             "MODE CHANGE",
  43.                             "CONSOLE","","","","","",""};
  44. #define    MENU_NO            9
  45. #define    MENU_DEFLT        5
  46.  
  47. /*
  48.     key input (real interupt) .. encode mode
  49.         return code 0 : no input
  50.                     1 : ESC key
  51.                     2 : down key
  52.                     3 : up key
  53.                     4 : right key
  54.                     5 : left key
  55.                     6 : CR key
  56.                     7 : 取消 key
  57. */
  58. int    key_in(void)
  59. {
  60. union    REGS    in;
  61. struct    SREGS    seg;
  62.  
  63.         int        endcode;
  64.         char    code;
  65.  
  66.                     /* key board status check */
  67.     in.h.ah = 0x09;
  68.     in.h.al = 0x01;
  69.     intreal(0x90, &in, &in, &seg);
  70.     if (in.h.dh == 0xff)    code = 0x00;
  71.     else    code = in.h.dl;
  72.  
  73.     switch ( code ){
  74.         case 0 :
  75.             endcode=0;
  76.             break;
  77.         case 0x1c :            /* righy arrow */
  78.             endcode=4;
  79.             break;
  80.         case 0x1d :            /* left  arrow */
  81.             endcode=5;
  82.             break;
  83.         case 0x1e :            /* up    arrow */
  84.             endcode=3;
  85.             break;
  86.         case 0x1f :            /* down  arrow */
  87.             endcode=2;
  88.             break;
  89.         case 0x1b :            /* ESC key */
  90.             endcode=1;
  91.             break;
  92.         case 0x0d :            /* CR key (実行 key on cosole) */
  93.             endcode=6;
  94.             break;
  95.         case 0x12 :            /* 実行 key (TOWNS OS) */
  96.             endcode=6;
  97.             break;
  98.         case 0x11 :            /* 取消 key  (TOWNS OS) */
  99.             endcode=7;
  100.             break;
  101.         case 0x18 :            /* 取消 key  (console) */
  102.             endcode=7;
  103.             break;
  104.         default :
  105.             endcode=0;
  106.             break;
  107.     }
  108.     return ( endcode );
  109. }
  110.  
  111.  
  112.  
  113. /*
  114.     mouse input
  115.         return code 0 : no action
  116.                     1 : right bottan
  117.                     2 : left bottan
  118.                     3 : both bottan
  119.                     &x: x posision
  120.                     &y: y posision
  121. */
  122. int    mouse_in(int *xpos, int *ypos)
  123. {
  124.         char    para[20];
  125.         int        x,y;
  126.         int        i,endcode=0;
  127.         int        botan_state;
  128. static    int        old_botan_state=0;
  129.  
  130.                     /* mouse status check */
  131.     MOS_rdpos(&botan_state,&x,&y);
  132.     if ( botan_state != old_botan_state ) {
  133.         for (i=0;i<CLICK_TIMING;i++) {
  134.             WORD(para+0)=0;
  135.             EGB_palette(egbwork,1,para);
  136.         }
  137.         MOS_rdpos(&botan_state,&x,&y);
  138.         switch ( botan_state ){
  139.             case 3 :        /* both bottan push */
  140.                 endcode=3;
  141.                 break;
  142.             case 1 :        /* left bottan push */
  143.                 endcode=2;
  144.                 break;
  145.             case 2 :        /* right bottan push */
  146.                 endcode=1;
  147.                 break;
  148.         }
  149.         old_botan_state=botan_state;
  150.     }
  151.     else endcode=0;
  152.     *xpos=x;
  153.     *ypos=y;
  154.  
  155.     return ( endcode ) ;
  156. }
  157.  
  158.  
  159. /*
  160.     pad input
  161.         return code 0 : no action
  162.                     1 : A trigger
  163.                     2 : B trigger
  164.                     3 : down key
  165.                     4 : up key
  166.                     5 : right key
  167.                     6 : left key
  168.                     7 : RUN key
  169.                     8 : SELECT key
  170. */
  171. int    pad_in(void)
  172. {
  173.         int        padstate,pad0out,pad1out;
  174.         int        endcode=0;
  175. static    int        padold=0x3f;
  176. static    int        repeat_count=200;
  177.  
  178.                     /* joy pad status check */
  179.     SND_joy_out(0x13, &pad0out, &pad1out);
  180.     padstate=pad0out & 0x3f;
  181.  
  182.     if ( padstate != 0x3f ){
  183.         if (padstate!=padold){
  184.             padold=padstate;
  185.             switch ( padstate ^ 0x3f ){
  186.                 case 0x10:        /* pad A key  */
  187.                     endcode=1;
  188.                     break;
  189.                 case 0x20:        /* pad B key */
  190.                     endcode=2;
  191.                     break;
  192.                 case 0x02:        /* down key  */
  193.                     endcode=3;
  194.                     break;
  195.                 case 0x01:        /* up key    */
  196.                     endcode=4;
  197.                     break;
  198.                 case 0x08:        /* right key */
  199.                     endcode=5;
  200.                     break;
  201.                 case 0x04:        /* left key  */
  202.                     endcode=6;
  203.                     break;
  204.                 case 0x0c:        /* run key   */
  205.                     endcode=7;
  206.                     break;
  207.                 case 0x03:        /* select key */
  208.                     endcode=8;
  209.                     break;
  210.             }
  211.         }
  212.         else{
  213.             endcode=0;
  214.             if (--repeat_count==0){
  215.                 padold=0x3f;
  216.                 repeat_count=200;
  217.             }
  218.         }
  219.     }
  220.     else{
  221.         padold=0x3f;
  222.         endcode=0;
  223.     }
  224.  
  225.     return ( endcode ) ;
  226. }
  227.  
  228.  
  229.  
  230. /*
  231.     直線の描画
  232. */
  233. void line(int x1, int y1, int x2, int y2, int col)
  234. {
  235.     char para[12];
  236.  
  237.     EGB_color(egbwork, 0, col);
  238.     WORD(para + 0) = 2;
  239.     WORD(para + 2) = x1;
  240.     WORD(para + 4) = y1;
  241.     WORD(para + 6) = x2;
  242.     WORD(para + 8) = y2;
  243.     EGB_connect(egbwork, para);
  244. }
  245.  
  246. /*
  247.     ボタンの描画
  248. */
  249. void bottan(int sx, int sy, int ex, int ey)
  250. {
  251.     box(sx, sy, ex, ey, BOTAN_COL,1);
  252.     line(sx, sy, sx, ey, HILIGHT);
  253. /*    line(sx + 1, sy + 1, sx + 1, ey - 1, HILIGHT);*/
  254.     line(sx, sy, ex, sy, HILIGHT);
  255. /*    line(sx + 1, sy + 1, ex - 1, sy + 1, HILIGHT);*/
  256.     line(sx, ey, ex, ey, SHADOW);
  257. /*    line(sx + 1, ey - 1, ex - 1, ey - 1, SHADOW);*/
  258.     line(ex, sy, ex, ey, SHADOW);
  259. /*    line(ex - 1, sy + 1, ex - 1, ey - 1, SHADOW);*/
  260. /*    line(sx, sy, sx + 1, sy + 1, SHADOW);*/
  261.     line(sx, sy, sx, sy, SHADOW);
  262. /*    line(ex, ey, ex - 1, ey - 1, HILIGHT);*/
  263.     line(ex, ey, ex, ey, HILIGHT);
  264. }
  265.  
  266. /*
  267.     ボタン押下の描画
  268. */
  269. void bpush(int sx, int sy, int ex, int ey)
  270. {
  271.     line(sx, sy, sx, ey, SHADOW);
  272. /*    line(sx + 1, sy + 1, sx + 1, ey - 1, SHADOW);*/
  273.     line(sx, sy, ex, sy, SHADOW);
  274. /*    line(sx + 1, sy + 1, ex - 1, sy + 1, SHADOW);*/
  275.     line(sx, ey, ex, ey, HILIGHT);
  276. /*    line(sx + 1, ey - 1, ex - 1, ey - 1, HILIGHT);*/
  277.     line(ex, sy, ex, ey, HILIGHT);
  278. /*    line(ex - 1, sy + 1, ex - 1, ey - 1, HILIGHT);*/
  279. /*    line(sx, sy, sx + 1, sy + 1, HILIGHT);*/
  280. /*    line(ex, ey, ex - 1, ey - 1, SHADOW);*/
  281.     line(sx, sy, sx, sy, HILIGHT);
  282.     line(ex, ey, ex, ey, SHADOW);
  283. }
  284.  
  285. /*
  286.     ボタン開放の描画
  287. */
  288. void bopen(int sx, int sy, int ex, int ey)
  289. {
  290.     line(sx, sy, sx, ey, HILIGHT);
  291. /*    line(sx + 1, sy + 1, sx + 1, ey - 1, HILIGHT);*/
  292.     line(sx, sy, ex, sy, HILIGHT);
  293. /*    line(sx + 1, sy + 1, ex - 1, sy + 1, HILIGHT);*/
  294.     line(sx, ey, ex, ey, SHADOW);
  295. /*    line(sx + 1, ey - 1, ex - 1, ey - 1, SHADOW);*/
  296.     line(ex, sy, ex, ey, SHADOW);
  297. /*    line(ex - 1, sy + 1, ex - 1, ey - 1, SHADOW);*/
  298. /*    line(sx, sy, sx + 1, sy + 1, SHADOW);*/
  299. /*    line(ex, ey, ex - 1, ey - 1, HILIGHT);*/
  300.     line(sx, sy, sx, sy, SHADOW);
  301.     line(ex, ey, ex, ey, HILIGHT);
  302. }
  303.  
  304. /*
  305.     initial panel set
  306. */
  307. void panelinit(int no, struct panel p[], char *s[], int cent)
  308. {
  309.     int i,j,k,n,sx,sy;
  310.  
  311.     for (n=0;n<no;n++){
  312.         box (p[n].xpos,p[n].ypos,
  313.                 p[n].xpos+p[n].xsize-1,p[n].ypos+p[n].ysize-1,BOTAN_COL,1);
  314.         i=j=k=0;
  315.         for (i=0;i<p[n].ysize/p[n].ybtnsize;i++){
  316.             for (j=0;j<p[n].xsize/p[n].xbtnsize;j++){
  317.                 sx=p[n].xpos+j*p[n].xbtnsize;
  318.                 sy=p[n].ypos+i*p[n].ybtnsize;
  319.                 bottan(sx,sy,sx+p[n].xbtnsize-1,sy+p[n].ybtnsize-1);
  320.                 EGB_color(egbwork, 0, BOTAN_TITLE_COL);
  321.                 if (cent==1){
  322.                     linedspv(sx+((p[n].xbtnsize-strlen(s[k])*8)/2),sy+18,s[k],
  323.                                                 0,BOTAN_TITLE_COL,BOTAN_COL);
  324.                 }
  325.                 else{
  326.                     linedspv(sx+2,sy+18,s[k],0,BOTAN_TITLE_COL,BOTAN_COL);
  327.                 }
  328.                 k++;
  329.             }
  330.         }
  331.     }
  332. }
  333.  
  334. /*
  335.     menu panel posision check
  336. */
  337. int        poscheck(int menuno, struct panel p[], int x, int y)
  338. {
  339.     int        digit;
  340.  
  341.     if (x>=p[menuno].xpos && x<p[menuno].xpos+p[menuno].xsize 
  342.                 && y>=p[menuno].ypos && y<p[menuno].ypos+p[menuno].ysize){
  343.         digit=(x-p[menuno].xpos)/p[menuno].xbtnsize
  344.             +((y-p[menuno].ypos)/p[menuno].ybtnsize)
  345.                 *(p[menuno].xsize/p[menuno].xbtnsize) + p[menuno].ini_digit;
  346.     }
  347.     else digit=-1;
  348.     return (digit);
  349. }
  350.  
  351. /*
  352.     which menu mouse cursol on check
  353. */
  354. int        whichmenu(int no, struct panel p[], int x, int y)
  355. {
  356.     int        j;
  357.  
  358.     for ( j=0;j<no;j++ ){
  359.         if (x>=p[j].xpos && x<p[j].xpos+p[j].xsize 
  360.                     && y>=p[j].ypos && y<p[j].ypos+p[j].ysize){
  361.             break;
  362.         }
  363.     }
  364.     if ( j!=no ) return (j);
  365.     else return (-1);
  366. }
  367.  
  368.  
  369.  
  370. /*
  371.     panel input read
  372.         input    int no    :panel kind no
  373.                 struct panel[]    :panel format
  374.                 on        :cursol on response lag
  375.         output    int        -1        : not on menu or cancel
  376.                         0..999    : on menu left bottan
  377.                     1000..1999    : on menu right bottan
  378.                     2000..2999    : on menu both bottan
  379. */
  380. int  panelread(int no, struct panel p[], int on )
  381. {
  382.     int        i,j,var,x,y;
  383.     int        sx,sy,digit,olddigit,flag;
  384.     int        contflag;
  385.     int        menuno;
  386.     int        defbtnsize=20;
  387.  
  388.     flag = 1 ;
  389.     while ( flag != 0 ){
  390.         MOS_rdpos(&var,&x,&y);
  391.         flag=var;
  392.     }
  393.     digit=olddigit=-1;
  394.  
  395.     contflag=1;
  396.     while ( contflag ) {
  397.         MOS_rdpos(&var,&x,&y);
  398.         menuno=whichmenu(no,p,x,y);
  399.         if ( on==1 ){
  400.             if (menuno==-1) digit=-1;
  401.             else digit=poscheck(menuno,p,x,y);
  402.             if (digit!=olddigit){
  403.                 olddigit=digit;
  404.  
  405.                 for (j=0;j<no;j++){
  406.                     if ( j==menuno ){
  407.                         for (i=0;i<((p[j].xsize/p[j].xbtnsize)
  408.                                 *(p[j].ysize/p[j].ybtnsize));i++){
  409.                             if ((p[j].xpos+p[j].xbtnsize
  410.                                         *(i%(p[j].xsize/p[j].xbtnsize)))<=x 
  411.                                     && (p[j].xpos+p[j].xbtnsize
  412.                                         *(i%(p[j].xsize/p[j].xbtnsize))
  413.                                         +p[j].xbtnsize)>x 
  414.                                     && (p[j].ypos+p[j].ybtnsize
  415.                                         *(i/(p[j].xsize/p[j].xbtnsize)))<=y 
  416.                                     && (p[j].ypos+p[j].ybtnsize
  417.                                         *(i/(p[j].xsize/p[j].xbtnsize))
  418.                                         +p[j].ybtnsize)>y ){
  419.                                 sx=p[j].xpos+(i%(p[j].xsize/p[j].xbtnsize))
  420.                                             *p[j].xbtnsize;
  421.                                 sy=p[j].ypos+(i/(p[j].xsize/p[j].xbtnsize))
  422.                                             *p[j].ybtnsize;
  423.                                 if ( p[j].ful==1 ){
  424.                                     bpush(sx,sy,sx+p[j].xbtnsize-1,
  425.                                                 sy+p[j].ybtnsize-1);
  426.                                 }
  427.                                 else{
  428.                                     box(sx,sy,sx+p[j].xbtnsize-1,
  429.                                         sy+p[j].ybtnsize-1,BOTAN_FRAME_COL,0);
  430.                                 }
  431.                             }
  432.                             else{
  433.                                 sx=p[j].xpos+(i%(p[j].xsize/p[j].xbtnsize))
  434.                                             *p[j].xbtnsize;
  435.                                 sy=p[j].ypos+(i/(p[j].xsize/p[j].xbtnsize))
  436.                                             *p[j].ybtnsize;
  437.                                 if ( p[j].ful==1 ){
  438.                                     bopen(sx,sy,sx+p[j].xbtnsize-1,
  439.                                                 sy+p[j].ybtnsize-1);
  440.                                 }
  441.                                 else{
  442.                                     box(sx,sy,sx+p[j].xbtnsize-1,
  443.                                         sy+p[j].ybtnsize-1,BACK_COL,0);
  444.                                 }
  445.                             }
  446.                         }
  447.                     }
  448.                     else{
  449.                         for (i=0;i<((p[j].xsize/p[j].xbtnsize)
  450.                                 *(p[j].ysize/p[j].ybtnsize));i++){
  451.                             sx=p[j].xpos+(i%(p[j].xsize/p[j].xbtnsize))
  452.                                         *p[j].xbtnsize;
  453.                             sy=p[j].ypos+(i/(p[j].xsize/p[j].xbtnsize))
  454.                                         *p[j].ybtnsize;
  455.                             if ( p[j].ful==1 ){
  456.                                 bopen(sx,sy,sx+p[j].xbtnsize-1,
  457.                                             sy+p[j].ybtnsize-1);
  458.                             }
  459.                             else{
  460.                                 box(sx,sy,sx+p[j].xbtnsize-1,
  461.                                     sy+p[j].ybtnsize-1,BACK_COL,0);
  462.                             }
  463.                         }
  464.                     }
  465.                 }
  466.             }
  467.         }
  468.  
  469.         if (menuno!=-1){
  470.                     /* mouse status check */
  471.             switch (mouse_in(&x,&y)){
  472.                 case 1 :            /* right bottan */
  473.                     digit=poscheck(menuno,p,x,y);
  474.                     digit=digit+1000;
  475.                     contflag=0;
  476.                     break;
  477.                 case 2 :            /* left bottan  */
  478.                     digit=poscheck(menuno,p,x,y);
  479.                     contflag=0;
  480.                     break;
  481.                 case 3 :            /* both bottan  */
  482.                     digit=poscheck(menuno,p,x,y);
  483.                     digit=digit+2000;
  484.                     contflag=0;
  485.                     break;
  486.                 default : break;
  487.             }
  488.  
  489.                     /* key board status check */
  490.             switch (key_in()){
  491.                 case 0 : break;        /* no input */
  492.                 case 1 :            /* ESC key  */
  493.                     digit=-1;
  494.                     contflag=0;
  495.                     break;
  496.                 case 2 :            /* down key */
  497.                     if ((j=whichmenu(no,p,x,y))!=-1) y=y+p[j].ybtnsize;
  498.                     else y=y+defbtnsize;
  499.                     MOS_setpos( x, y );
  500.                     break;
  501.                 case 3 :            /* up key   */
  502.                     if ((j=whichmenu(no,p,x,y))!=-1) y=y-p[j].ybtnsize;
  503.                     else y=y-defbtnsize;
  504.                     MOS_setpos( x, y );
  505.                     break;
  506.                 case 4 :            /* right key */
  507.                     if ((j=whichmenu(no,p,x,y))!=-1) x=x+p[j].xbtnsize;
  508.                     else x=x+defbtnsize;
  509.                     MOS_setpos( x, y );
  510.                     break;
  511.                 case 5 :            /* left key  */
  512.                     if ((j=whichmenu(no,p,x,y))!=-1) x=x-p[j].xbtnsize;
  513.                     else x=x-defbtnsize;
  514.                     MOS_setpos( x, y );
  515.                     break;
  516.                 case 6 :            /* CR/実行 key  */
  517.                     digit=poscheck(menuno,p,x,y);
  518.                     contflag=0;
  519.                     break;
  520.                 case 7 :            /* 取消 key  */
  521.                     digit=poscheck(menuno,p,x,y);
  522.                     digit=digit+1000;
  523.                     contflag=0;
  524.                     break;
  525.                 default : break;
  526.             }
  527.  
  528.                     /* joy pad status check */
  529.             switch (pad_in()){
  530.                 case 0 : break;        /* no input  */
  531.                 case 1 :            /* A trigger */
  532.                     digit=poscheck(menuno,p,x,y);
  533.                     contflag=0;
  534.                     break;
  535.                 case 2 :            /* B trigger */
  536.                     digit=poscheck(menuno,p,x,y);
  537.                     digit=digit+1000;
  538.                     contflag=0;
  539.                     break;
  540.                 case 3 :            /* down key  */
  541.                     if ((j=whichmenu(no,p,x,y))!=-1) y=y+p[j].ybtnsize;
  542.                     else y=y+defbtnsize;
  543.                     MOS_setpos( x, y );
  544.                     break;
  545.                 case 4 :            /* up key    */
  546.                     if ((j=whichmenu(no,p,x,y))!=-1) y=y-p[j].ybtnsize;
  547.                     else y=y-defbtnsize;
  548.                     MOS_setpos( x, y );
  549.                     break;
  550.                 case 5 :            /* right key */
  551.                     if ((j=whichmenu(no,p,x,y))!=-1) x=x+p[j].xbtnsize;
  552.                     else x=x+defbtnsize;
  553.                     MOS_setpos( x, y );
  554.                     break;
  555.                 case 6 :            /* left key   */
  556.                     if ((j=whichmenu(no,p,x,y))!=-1) x=x-p[j].xbtnsize;
  557.                     else x=x-defbtnsize;
  558.                     MOS_setpos( x, y );
  559.                     break;
  560.                 case 7 :            /* RUN key   */
  561.                     digit=poscheck(menuno,p,x,y);
  562.                     digit=digit+2000;
  563.                     contflag=0;
  564.                     break;
  565.                 case 8 :            /* SELECT key   */
  566.                     digit=poscheck(menuno,p,x,y);
  567.                     digit=digit+2000;
  568.                     contflag=0;
  569.                     break;
  570.                 default : break;
  571.             }
  572.         }
  573.     }
  574.     return ( digit );
  575. }
  576.  
  577. /*
  578.     menu display and read
  579. */
  580. int  menuread(void)
  581. {
  582.     int        i,endcode;
  583.     struct    panel    n_menu[1];
  584.  
  585.     n_menu[0].xpos=PANEL_SX;
  586.     n_menu[0].ypos=PANEL_SY;
  587.     n_menu[0].xsize=BOTAN_X;
  588.     n_menu[0].ysize=BOTAN_Y*MENU_NO;
  589.     n_menu[0].xbtnsize=BOTAN_X;
  590.     n_menu[0].ybtnsize=BOTAN_Y;
  591.     panelinit(1,n_menu,menutable,1);
  592.     MOS_horizon( PANEL_SX,PANEL_SX+BOTAN_X-1 );
  593.     MOS_vertical( PANEL_SY,PANEL_SY+BOTAN_Y*MENU_NO-1 );
  594.     MOS_setpos( PANEL_SX+BOTAN_X/2, PANEL_SY+BOTAN_Y*MENU_DEFLT+10 );
  595.     MOS_disp( 1 );
  596.  
  597.     n_menu[0].xpos=PANEL_SX;
  598.     n_menu[0].ypos=PANEL_SY;
  599.     n_menu[0].xsize=BOTAN_X;
  600.     n_menu[0].ysize=BOTAN_Y*MENU_NO;
  601.     n_menu[0].xbtnsize=BOTAN_X;
  602.     n_menu[0].ybtnsize=BOTAN_Y;
  603.     n_menu[0].ful=1;
  604.     n_menu[0].disp=1;
  605.     n_menu[0].ini_digit=0;
  606.     while ( (i = panelread (1, n_menu, 1)) >= 2000 );
  607.     MOS_disp( 0 );
  608.  
  609.     if ( i<0 || i>=1000 ) endcode = -1;
  610.     else{
  611.         switch ( i ){
  612.             case 0 :    /* next title */
  613.                 endcode=5;
  614.                 break;
  615.             case 1 :    /* previous title */
  616.                 endcode=6;
  617.                 break;
  618.             case 2 :    /* top text */
  619.                 endcode=7;
  620.                 break;
  621.             case 3 :    /* last text */
  622.                 endcode=8;
  623.                 break;
  624.             case 4 :    /* log update & quit */
  625.                 endcode=9;
  626.                 break;
  627.             case 5 :    /* quit */
  628.                 endcode=0;
  629.                 break;
  630.             case 6 :    /* title mode switch */
  631.                 endcode=10;
  632.                 break;
  633.             case 7 :    /* new file select */
  634.                 endcode=11;
  635.                 break;
  636.             case 8 :    /* mode change */
  637.                 endcode=12;
  638.                 break;
  639.             case 9 :    /* console */
  640.                 endcode=13;
  641.                 break;
  642.             default :    /* no effect */
  643.                 endcode=-1;
  644.                 break;
  645.         }
  646.     }
  647.     return (endcode);
  648. }
  649.  
  650.